import { useEffect, useState } from 'react';
import { makeToast } from '@nova-hf/ui';
import {
  ContractStatus,
  OptionVariant,
  useContractApplicableVariantsLazyQuery,
  useContractApplicableVariantsQuery,
  useGetContractIdQuery,
} from 'typings/graphql';

import { CardItem } from '../components/SellingCardItem';

export const createCardItemFromOption = (option: OptionVariant): CardItem => {
  return {
    id: option.id,
    title: option.name,
    description: '',
    price: option.monthlyCharge ?? 0,
    isCurrent: option.isCurrent ?? false,
  };
};

type FetchOptionsProps = {
  customerId: string;
  serviceId?: string;
  contractId?: string;
};

export const useFetchOptions = ({ customerId, serviceId, contractId }: FetchOptionsProps) => {
  const [loading, setLoading] = useState<boolean>(true);
  const [error, setError] = useState<string>();
  const [optionsAsCardItems, setOptionsAsCardItems] = useState<CardItem[]>();
  const shouldSkip = !!contractId;

  const [getApplicableVariants] = useContractApplicableVariantsLazyQuery();

  const { data: contractIdData } = useGetContractIdQuery({
    variables: { input: { customerId, serviceId } },
    skip: shouldSkip,
    onCompleted: (data) => {
      const contract = data?.contracts.contracts.find(
        (contract) =>
          contract.status === ContractStatus.Active || contract.status === ContractStatus.Pending,
      );
      if (contract?.id) {
        try {
          getApplicableVariants({
            variables: {
              input: {
                contractId: contract?.id,
              },
            },
          });
        } catch (error) {
          if (error instanceof Error) {
            makeToast.danger('', error.message);
          }
        }
      }
    },
  });

  const contract = contractIdData?.contracts.contracts.find(
    (contract) =>
      contract.status === ContractStatus.Active || contract.status === ContractStatus.Pending,
  );

  const { data } = useContractApplicableVariantsQuery({
    variables: {
      input: {
        contractId: contract ? contract.id : contractId ? contractId : '',
      },
    },
    onCompleted: () => setLoading(false),
    onError: ({ message }) => setError(message),
  });

  useEffect(() => {
    const currentContract = data?.contractApplicableVariants?.[0]?.variant?.options;
    if (currentContract?.length) {
      const optionsCardItems = currentContract
        ?.map((option) => {
          if (option?.__typename === 'SubscriptionVariantOption' && option.variants.length) {
            return option.variants
              .map((variantOption: OptionVariant) => {
                if (variantOption.__typename === 'OptionVariant' && variantOption.id) {
                  return createCardItemFromOption(variantOption);
                }
              })
              .flat();
          }
        })
        .flat();
      if (!!optionsCardItems && optionsCardItems?.length && optionsCardItems) {
        setOptionsAsCardItems(optionsCardItems.filter((n) => n) as CardItem[]);
      }
    }
  }, [data]);

  return {
    optionsAsCardItems,
    loading,
    error,
  };
};

export default useFetchOptions;